use crate::ast::{ASTNode, Argument, BinOp, Param, SourceLocation};
use crate::config::InterpreterConfig;
use crate::errors::{
    RuntimeError, index_out_of_bounds_error, invalid_operation_error, type_mismatch_error,
};
use crate::interpreter::value::{Value, ValueData};
use std::collections::HashMap;
use std::path::PathBuf;
use std::str;

#[allow(dead_code)]
const PI: f64 = 3.141592653589793;

/// 处理转义字符序列
fn process_escape_sequences(input: &str) -> String {
    // 词法分析器已经处理了转义序列，这里只需要返回原字符串
    // 如果将来需要其他处理，可以在这里添加
    input.to_string()
}

#[allow(dead_code)]
pub struct Interpreter {
    globals: HashMap<String, Value>,
    locals: Vec<HashMap<String, Value>>,
    constants: HashMap<String, Value>,
    functions: HashMap<String, Value>,
    classes: HashMap<String, Value>,
    exports: std::collections::HashSet<String>,
    return_value: Option<Value>,
    should_break: bool,
    should_continue: bool,
    in_loop: bool,
    config: InterpreterConfig,
    recursion_depth: u32,
    current_file_path: Option<PathBuf>,
}

impl Interpreter {
    pub fn new() -> Self {
        Interpreter {
            globals: HashMap::new(),
            locals: Vec::new(),
            constants: HashMap::new(),
            functions: HashMap::new(),
            classes: HashMap::new(),
            exports: std::collections::HashSet::new(),
            return_value: None,
            should_break: false,
            should_continue: false,
            in_loop: false,
            config: InterpreterConfig::default(),
            recursion_depth: 0,
            current_file_path: None,
        }
    }

    pub fn with_config(config: InterpreterConfig) -> Self {
        Interpreter {
            globals: HashMap::new(),
            locals: Vec::new(),
            constants: HashMap::new(),
            functions: HashMap::new(),
            classes: HashMap::new(),
            exports: std::collections::HashSet::new(),
            return_value: None,
            should_break: false,
            should_continue: false,
            in_loop: false,
            config,
            recursion_depth: 0,
            current_file_path: None,
        }
    }

    /// 启用安全检查
    pub fn enable_safety_checks(&mut self) {
        // 安全检查功能开发中
        // 这里可以添加安全检查逻辑，如循环计数器、递归深度检查等
    }

    /// 辅助方法：仅在调试模式下输出信息
    fn debug_println(&self, args: std::fmt::Arguments) {
        if self.config.execution_mode.is_debug() {
            eprintln!("{}", args);
        }
    }

    /// 检查递归深度是否超过限制
    fn check_recursion_depth(&mut self) -> Result<(), RuntimeError> {
        if let Some(max_depth) = self.config.resource_limits.max_recursion_depth {
            if self.recursion_depth > max_depth {
                return Err(RuntimeError::new(
                    crate::errors::ErrorKind::RecursionDepthExceeded,
                    format!("递归深度超过限制: {} > {}", self.recursion_depth, max_depth),
                ));
            }
        }
        Ok(())
    }

    /// 增加递归深度
    fn increment_recursion_depth(&mut self) -> Result<(), RuntimeError> {
        self.recursion_depth += 1;
        if self.config.execution_mode.is_debug() {
            self.debug_println(format_args!("递归深度增加到: {}", self.recursion_depth));
        }
        self.check_recursion_depth()
    }

    /// 减少递归深度
    fn decrement_recursion_depth(&mut self) {
        if self.recursion_depth > 0 {
            self.recursion_depth -= 1;
            if self.config.execution_mode.is_debug() {
                self.debug_println(format_args!("递归深度减少到: {}", self.recursion_depth));
            }
        }
    }

    pub fn eval(&mut self, node: &ASTNode) -> Result<Value, RuntimeError> {
        match node {
            ASTNode::Program {
                preamble,
                body,
                epilogue,
                location: _,
            } => {
                for stmt in preamble {
                    self.eval(stmt)?;
                }
                for stmt in body {
                    self.eval(stmt)?;
                }
                for stmt in epilogue {
                    self.eval(stmt)?;
                }
                Ok(Value::null())
            }
            ASTNode::Import {
                path,
                symbols,
                location: _,
            } => {
                self.load_module(path, symbols.as_deref())?;
                Ok(Value::null())
            }
            ASTNode::Chapter {
                name: _,
                intro,
                body,
                conclusion,
                location: _,
            } => {
                for stmt in intro {
                    self.eval(stmt)?;
                }
                for stmt in body {
                    self.eval(stmt)?;
                }
                for stmt in conclusion {
                    self.eval(stmt)?;
                }
                Ok(Value::null())
            }
            ASTNode::ConstDeclaration {
                name,
                value,
                location: _,
                type_name: _,
            } => {
                let val = self.eval(value)?;
                self.constants.insert(name.clone(), val);
                Ok(Value::null())
            }
            ASTNode::VarDeclaration {
                name,
                value,
                location: _,
                type_name: _,
            } => {
                let val = self.eval(value)?;
                self.set_variable(name.clone(), val);
                Ok(Value::null())
            }
            ASTNode::Assignment {
                name,
                value,
                location: _,
            } => {
                let val = self.eval(value)?;
                self.set_variable(name.clone(), val);
                Ok(Value::null())
            }
            ASTNode::FunctionDef {
                name,
                return_type,
                params,
                body,
                location: _,
            } => {
                // 直接传递参数对象
                let func = Value::function(
                    params.clone(),
                    body.clone(),
                    HashMap::new(),
                    return_type.clone(),
                );
                self.functions.insert(name.clone(), func);
                Ok(Value::null())
            }
            ASTNode::FunctionCall {
                name,
                args,
                location,
            } => self.call_function_with_args(name, args, location),
            ASTNode::Print(exprs, is_print_line, _) => {
                for expr in exprs {
                    let value = self.eval(expr)?;
                    let output_text = match &value.data {
                        ValueData::String(s) => {
                            // 处理字符串中的变量替换
                            let mut result = s.clone();
                            let mut start = 0;

                            // 查找所有 {变量名} 模式
                            while let Some(open_pos) = result[start..].find('{') {
                                let open_pos = start + open_pos;
                                if let Some(close_pos) = result[open_pos..].find('}') {
                                    let close_pos = open_pos + close_pos;
                                    let var_name = &result[open_pos + 1..close_pos];

                                    // 尝试获取变量值
                                    let var_value = self.get_variable(var_name);
                                    let replacement = match var_value {
                                        Ok(val) => val.to_string(),
                                        Err(_) => format!("{{{}}}", var_name), // 如果变量不存在，保持原样
                                    };

                                    // 替换变量
                                    result.replace_range(open_pos..=close_pos, &replacement);
                                    start = open_pos + replacement.len();
                                } else {
                                    break;
                                }
                            }

                            process_escape_sequences(&result)
                        }
                        _ => value.to_string(),
                    };

                    if *is_print_line {
                        println!("{}", output_text);
                    } else {
                        print!("{}", output_text);
                    }
                }
                Ok(Value::null())
            }
            ASTNode::If {
                condition,
                then_block,
                else_if_conditions,
                else_if_blocks,
                else_block,
                location: _,
            } => {
                let cond_value = self.eval(condition)?;
                if self.is_truthy(&cond_value) {
                    for stmt in then_block {
                        self.eval(stmt)?;
                    }
                } else {
                    let mut matched = false;
                    for (i, else_if_cond) in else_if_conditions.iter().enumerate() {
                        let else_if_value = self.eval(else_if_cond)?;
                        if self.is_truthy(&else_if_value) {
                            if let Some(block) = else_if_blocks.get(i) {
                                for stmt in block {
                                    self.eval(stmt)?;
                                }
                            }
                            matched = true;
                            break;
                        }
                    }

                    if !matched {
                        if let Some(else_stmts) = else_block {
                            for stmt in else_stmts {
                                self.eval(stmt)?;
                            }
                        }
                    }
                }
                Ok(Value::null())
            }
            // 当 …… 之时 …… 毕 循环结构，当条件为“真”时，执行循环体，当条件为“伪”时，结束执行。
            ASTNode::While {
                condition,
                body,
                location: _,
            } => {
                // 保存当前循环状态
                let old_in_loop = self.in_loop;
                self.in_loop = true;

                loop {
                    let cond = self.eval(condition)?;
                    if !self.is_truthy(&cond) {
                        break;
                    }

                    for stmt in body {
                        self.eval(stmt)?;

                        // 检查是否有返回值
                        if self.return_value.is_some() {
                            break;
                        }

                        // 检查break语句
                        if self.should_break {
                            break;
                        }

                        // 检查continue语句
                        if self.should_continue {
                            break;
                        }
                    }

                    // 如果有返回值，跳出循环
                    if self.return_value.is_some() {
                        break;
                    }

                    // 如果有break，跳出循环
                    if self.should_break {
                        self.should_break = false;
                        break;
                    }

                    // 如果有continue，重置标志并继续下一次迭代
                    if self.should_continue {
                        self.should_continue = false;
                        continue;
                    }
                }

                // 恢复循环状态
                self.in_loop = old_in_loop;
                Ok(Value::null())
            }
            //  行 <语句块> 直至 <条件> 毕 循环结构，当条件为“真”时，结束执行，当条件为“伪”时一直执行。
            ASTNode::DoWhile {
                body,
                condition,
                location: _,
            } => {
                // 保存当前循环状态
                let old_in_loop = self.in_loop;
                self.in_loop = true;

                loop {
                    // 先执行循环体
                    for stmt in body {
                        self.eval(stmt)?;

                        // 检查是否有返回值
                        if self.return_value.is_some() {
                            break;
                        }

                        // 检查break语句
                        if self.should_break {
                            break;
                        }

                        // 检查continue语句
                        if self.should_continue {
                            break;
                        }
                    }

                    // 如果有break或return，跳出循环
                    if self.return_value.is_some() || self.should_break {
                        if self.should_break {
                            self.should_break = false;
                        }
                        break;
                    }

                    // 如果有continue，跳过条件检查，直接进入下一次迭代
                    if self.should_continue {
                        self.should_continue = false;
                        continue;
                    }

                    // 再检查条件
                    let cond = self.eval(condition)?;
                    let is_truthy = self.is_truthy(&cond);

                    // 当条件为"真"时结束执行，当条件为"伪"时继续执行
                    if is_truthy {
                        break;
                    }
                }

                // 恢复循环状态
                self.in_loop = old_in_loop;
                Ok(Value::null())
            }
            ASTNode::ForEach {
                variable,
                iterable,
                body,
                ..
            } => {
                // 保存当前循环状态
                let old_in_loop = self.in_loop;
                self.in_loop = true;

                let iter_val = self.eval(iterable)?;

                // 根据可迭代对象的类型进行遍历
                match &iter_val.data {
                    ValueData::List(elements) => {
                        for element in elements.borrow().iter() {
                            // 创建新的局部作用域
                            self.locals.push(HashMap::new());
                            // 绑定循环变量
                            self.locals
                                .last_mut()
                                .unwrap()
                                .insert(variable.clone(), element.clone());

                            // 执行循环体
                            for stmt in body {
                                self.eval(stmt)?;
                                // 检查是否有返回值
                                if self.return_value.is_some() {
                                    break;
                                }

                                // 检查break语句
                                if self.should_break {
                                    break;
                                }

                                // 检查continue语句
                                if self.should_continue {
                                    break;
                                }
                            }

                            // 恢复局部作用域
                            self.locals.pop();

                            // 如果有break，跳出整个循环
                            if self.return_value.is_some() || self.should_break {
                                if self.should_break {
                                    self.should_break = false;
                                }
                                break;
                            }

                            // 如果有continue，跳过剩余语句，直接进入下一次迭代
                            if self.should_continue {
                                self.should_continue = false;
                                continue;
                            }
                        }
                    }
                    ValueData::Set(elements) => {
                        for element in elements.borrow().iter() {
                            // 创建新的局部作用域
                            self.locals.push(HashMap::new());
                            // 绑定循环变量
                            self.locals
                                .last_mut()
                                .unwrap()
                                .insert(variable.clone(), element.0.clone());

                            // 执行循环体
                            for stmt in body {
                                self.eval(stmt)?;
                                // 检查是否有返回值
                                if self.return_value.is_some() {
                                    break;
                                }

                                // 检查break语句
                                if self.should_break {
                                    break;
                                }

                                // 检查continue语句
                                if self.should_continue {
                                    break;
                                }
                            }

                            // 恢复局部作用域
                            self.locals.pop();

                            // 如果有break，跳出整个循环
                            if self.return_value.is_some() || self.should_break {
                                if self.should_break {
                                    self.should_break = false;
                                }
                                break;
                            }

                            // 如果有continue，跳过剩余语句，直接进入下一次迭代
                            if self.should_continue {
                                self.should_continue = false;
                                continue;
                            }
                        }
                    }
                    ValueData::Dict(items) => {
                        for (key, value) in items.borrow().iter() {
                            // 创建新的局部作用域
                            self.locals.push(HashMap::new());
                            // 绑定循环变量为键值对
                            let pair =
                                Value::tuple(vec![Value::string(key.clone()), value.clone()]);
                            self.locals
                                .last_mut()
                                .unwrap()
                                .insert(variable.clone(), pair);

                            // 执行循环体
                            for stmt in body {
                                self.eval(stmt)?;
                                // 检查是否有返回值
                                if self.return_value.is_some() {
                                    break;
                                }

                                // 检查break语句
                                if self.should_break {
                                    break;
                                }

                                // 检查continue语句
                                if self.should_continue {
                                    break;
                                }
                            }

                            // 恢复局部作用域
                            self.locals.pop();

                            // 如果有break，跳出整个循环
                            if self.return_value.is_some() || self.should_break {
                                if self.should_break {
                                    self.should_break = false;
                                }
                                break;
                            }

                            // 如果有continue，跳过剩余语句，直接进入下一次迭代
                            if self.should_continue {
                                self.should_continue = false;
                                continue;
                            }
                        }
                    }
                    ValueData::Tuple(items) => {
                        for element in items {
                            // 创建新的局部作用域
                            self.locals.push(HashMap::new());
                            // 绑定循环变量
                            self.locals
                                .last_mut()
                                .unwrap()
                                .insert(variable.clone(), element.clone());

                            // 执行循环体
                            for stmt in body {
                                self.eval(stmt)?;
                                // 检查是否有返回值
                                if self.return_value.is_some() {
                                    break;
                                }

                                // 检查break语句
                                if self.should_break {
                                    break;
                                }

                                // 检查continue语句
                                if self.should_continue {
                                    break;
                                }
                            }

                            // 恢复局部作用域
                            self.locals.pop();

                            // 如果有break，跳出整个循环
                            if self.return_value.is_some() || self.should_break {
                                if self.should_break {
                                    self.should_break = false;
                                }
                                break;
                            }

                            // 如果有continue，跳过剩余语句，直接进入下一次迭代
                            if self.should_continue {
                                self.should_continue = false;
                                continue;
                            }
                        }
                    }
                    ValueData::String(s) => {
                        for ch in s.chars() {
                            // 创建新的局部作用域
                            self.locals.push(HashMap::new());
                            // 绑定循环变量为字符
                            self.locals
                                .last_mut()
                                .unwrap()
                                .insert(variable.clone(), Value::string(ch.to_string()));

                            // 执行循环体
                            for stmt in body {
                                self.eval(stmt)?;
                                // 检查是否有返回值
                                if self.return_value.is_some() {
                                    break;
                                }

                                // 检查break语句
                                if self.should_break {
                                    break;
                                }

                                // 检查continue语句
                                if self.should_continue {
                                    break;
                                }
                            }

                            // 恢复局部作用域
                            self.locals.pop();

                            // 如果有break，跳出整个循环
                            if self.return_value.is_some() || self.should_break {
                                if self.should_break {
                                    self.should_break = false;
                                }
                                break;
                            }

                            // 如果有continue，跳过剩余语句，直接进入下一次迭代
                            if self.should_continue {
                                self.should_continue = false;
                                continue;
                            }
                        }
                    }
                    _ => {
                        return Err(invalid_operation_error(
                            "遍历",
                            &format!("无法遍历类型: {}", iter_val.type_name),
                        ));
                    }
                }

                // 恢复循环状态
                self.in_loop = old_in_loop;
                Ok(Value::null())
            }
            ASTNode::ForRange {
                variable,
                start,
                end,
                step,
                body,
                ..
            } => {
                // 保存当前循环状态
                let old_in_loop = self.in_loop;
                self.in_loop = true;

                // 计算起始值、结束值和步长
                let start_val = self.eval(start)?;
                let end_val = self.eval(end)?;
                let step_val = match step {
                    Some(step_expr) => self.eval(step_expr)?,
                    None => Value::number(1.0), // 默认步长为1
                };

                // 确保所有值都是数字类型
                let start_num = match &start_val.data {
                    ValueData::Number(n) => *n,
                    _ => {
                        return Err(type_mismatch_error("数字", &start_val.type_name).into());
                    }
                };

                let end_num = match &end_val.data {
                    ValueData::Number(n) => *n,
                    _ => {
                        return Err(type_mismatch_error("数字", &end_val.type_name).into());
                    }
                };

                let step_num = match &step_val.data {
                    ValueData::Number(n) => *n,
                    _ => {
                        return Err(type_mismatch_error("数字", &step_val.type_name).into());
                    }
                };

                // 检查步长是否为0
                if step_num == 0.0 {
                    return Err(invalid_operation_error("循环", "步长不能为0"));
                }

                // 根据步长正负决定循环方向
                let mut current = start_num;
                let condition = if step_num > 0.0 {
                    |c: f64, e: f64| c <= e
                } else {
                    |c: f64, e: f64| c >= e
                };

                // 执行循环
                while condition(current, end_num) {
                    // 创建新的局部作用域
                    self.locals.push(HashMap::new());
                    // 绑定循环变量
                    self.locals
                        .last_mut()
                        .unwrap()
                        .insert(variable.clone(), Value::number(current));

                    // 执行循环体
                    for stmt in body {
                        self.eval(stmt)?;
                        // 检查是否有返回值
                        if self.return_value.is_some() {
                            break;
                        }
                        // 检查break语句
                        if self.should_break {
                            break;
                        }

                        // 检查continue语句
                        if self.should_continue {
                            break;
                        }
                    }

                    // 恢复局部作用域
                    self.locals.pop();

                    // 如果有break，跳出整个循环
                    if self.return_value.is_some() || self.should_break {
                        if self.should_break {
                            self.should_break = false;
                        }
                        break;
                    }

                    // 如果有continue，重置标志并继续下一次迭代
                    if self.should_continue {
                        self.should_continue = false;
                        // 更新循环变量后继续下一次迭代
                        current += step_num;
                        continue;
                    }

                    // 更新循环变量
                    current += step_num;
                }

                // 恢复循环状态
                self.in_loop = old_in_loop;
                Ok(Value::null())
            }
            ASTNode::ForDictEach {
                key_var,
                value_var,
                iterable,
                body,
                ..
            } => {
                // 保存当前循环状态
                let old_in_loop = self.in_loop;
                self.in_loop = true;

                let iter_val = self.eval(iterable)?;

                // 字典遍历只支持字典类型
                match &iter_val.data {
                    ValueData::Dict(items) => {
                        for (key, value) in items.borrow().iter() {
                            // 创建新的局部作用域
                            self.locals.push(HashMap::new());
                            // 绑定键变量
                            self.locals
                                .last_mut()
                                .unwrap()
                                .insert(key_var.clone(), Value::string(key.clone()));
                            // 绑定值变量
                            self.locals
                                .last_mut()
                                .unwrap()
                                .insert(value_var.clone(), value.clone());

                            // 执行循环体
                            for stmt in body {
                                self.eval(stmt)?;
                                // 检查是否有返回值
                                if self.return_value.is_some() {
                                    break;
                                }

                                // 检查break语句
                                if self.should_break {
                                    break;
                                }
                                // 检查continue语句
                                if self.should_continue {
                                    break;
                                }
                            }

                            // 恢复局部作用域
                            self.locals.pop();

                            // 如果有break，跳出整个循环
                            if self.return_value.is_some() || self.should_break {
                                if self.should_break {
                                    self.should_break = false;
                                }
                                break;
                            }

                            // 如果有continue，跳过剩余语句，直接进入下一次迭代
                            if self.should_continue {
                                self.should_continue = false;
                                continue;
                            }
                        }
                    }
                    _ => {
                        return Err(invalid_operation_error(
                            "字典遍历",
                            &format!(
                                "无法进行键值对遍历的类型: {}, 仅支持字典类型",
                                iter_val.type_name
                            ),
                        ));
                    }
                }

                // 恢复循环状态
                self.in_loop = old_in_loop;
                Ok(Value::null())
            }

            ASTNode::Return(expr, _) => {
                let value = if let Some(e) = expr {
                    self.eval(e)?
                } else {
                    Value::null()
                };
                self.return_value = Some(value.clone());
                Ok(value)
            }
            ASTNode::Export(names, _) => {
                for name in names {
                    self.exports.insert(name.clone());
                }
                Ok(Value::null())
            }
            ASTNode::BinaryOp {
                left,
                op,
                right,
                location: _,
            } => {
                let left_val = self.eval(left)?;
                let right_val = self.eval(right)?;
                self.eval_binary_op(&left_val, op, &right_val)
            }

            ASTNode::UnaryOp {
                op,
                operand,
                location: _,
            } => {
                let val = self.eval(operand)?;
                self.eval_unary_op(op, &val)
            }
            ASTNode::Identifier(name, _) => {
                if let Some(val) = self.constants.get(name) {
                    return Ok(val.clone());
                }

                match self.get_variable(name) {
                    Ok(val) => Ok(val),
                    Err(_) => {
                        // 检查是否是函数
                        if let Some(func) = self.functions.get(name) {
                            return Ok(func.clone());
                        }

                        // 检查是否是类名，如果是则创建实例
                        if let Some(class_val) = self.classes.get(name).cloned() {
                            // 创建类实例 - 复制类的字段
                            if let ValueData::Object(class_fields) = &class_val.data {
                                let class_fields_ref = class_fields.borrow();
                                let mut instance_fields = HashMap::new();

                                // 复制所有字段到实例中（包括方法）
                                for (field_name, field_value) in class_fields_ref.iter() {
                                    instance_fields.insert(field_name.clone(), field_value.clone());
                                }

                                // 创建实例对象
                                let instance = Value::object(instance_fields);
                                return Ok(instance);
                            }
                        }
                        Err(self.format_error(&format!("未定义的标识符: {}", name), Some(node)))
                    }
                }
            }

            ASTNode::ClassDef {
                name,
                fields,
                methods,
                location: _,
            } => {
                // 存储类定义，包括字段和方法
                let mut class_fields = HashMap::new();
                class_fields.insert("名称".to_string(), Value::string(name.clone()));

                // 存储实例字段及其初始值
                for (field_name, initial_value) in fields {
                    let field_value = if let Some(value_node) = initial_value {
                        // 如果有初始值，评估它
                        match self.eval(value_node) {
                            Ok(val) => val,
                            Err(e) => return Err(e), // 如果评估失败，返回错误
                        }
                    } else {
                        // 没有初始值，使用null
                        Value::null()
                    };
                    class_fields.insert(field_name.clone(), field_value);
                }

                // 将方法存储为函数对象
                for (method_name, (params, body)) in methods {
                    // 转换参数格式 - 从 Vec<String> 转换为 Vec<Param>
                    let method_params: Vec<Param> = params
                        .iter()
                        .map(|param_name| Param {
                            name: param_name.clone(),
                            type_name: None,
                            default_value: None,
                            is_varargs: false,
                            location: None,
                        })
                        .collect();

                    let method_func = Value::function(
                        method_params,
                        body.clone(),
                        HashMap::new(), // 空闭包环境
                        None,           // 无返回类型
                    );
                    class_fields.insert(method_name.clone(), method_func);
                }

                self.classes
                    .insert(name.clone(), Value::object(class_fields));
                Ok(Value::null())
            }

            ASTNode::MemberAccess {
                object,
                field,
                location,
            } => {
                let obj_val = self.eval(object)?;
                match &obj_val.data {
                    ValueData::Object(fields) => {
                        let fields_ref = fields.borrow();
                        if let Some(val) = fields_ref.get(field) {
                            Ok(val.clone())
                        } else {
                            let error = invalid_operation_error(
                                "成员访问",
                                &format!("字段不存在: {}", field),
                            );
                            if let Some(loc) = location {
                                Err(error.with_location(".".to_string(), loc.line, loc.column))
                            } else {
                                Err(error)
                            }
                        }
                    }
                    _ => Err(self.format_error("只能访问对象的成员", Some(node))),
                }
            }

            ASTNode::MemberAssign {
                object,
                field,
                value,
                location: _,
            } => {
                let obj_val = self.eval(object)?;
                let val = self.eval(value)?;

                match &obj_val.data {
                    ValueData::Object(fields) => {
                        let mut fields_ref = fields.borrow_mut();
                        fields_ref.insert(field.clone(), val);
                        Ok(Value::null())
                    }
                    _ => Err(invalid_operation_error("成员赋值", "只能给对象的成员赋值")),
                }
            }

            ASTNode::MethodCall {
                object,
                method,
                args,
                location,
            } => {
                let obj_val = self.eval(object)?;

                // 首先获取函数字段（避免借用冲突）
                let function_value = if let ValueData::Object(fields) = &obj_val.data {
                    let fields_ref = fields.borrow();
                    fields_ref.get(method).cloned()
                } else {
                    None
                };

                // 如果找到函数字段，检查它是否是函数
                if let Some(field_val) = function_value {
                    if let ValueData::Function {
                        params,
                        body,
                        closure: _,
                        return_type: _,
                    } = &field_val.data
                    {
                        // 这是一个函数字段，直接调用它
                        let mut arg_values = Vec::new();
                        for arg in args {
                            arg_values.push(self.eval(&arg)?);
                        }

                        // 保存当前局部变量并创建新的局部作用域
                        self.locals.push(HashMap::new());

                        // 绑定self参数（"其"）- 使用原始对象，而不是克隆
                        // 这样方法内的修改会持久化到原始对象
                        // 注意：我们需要在插入后重新获取obj_val，因为它被移动了
                        self.locals
                            .last_mut()
                            .unwrap()
                            .insert("其".to_string(), obj_val.clone());

                        // 绑定函数参数
                        for (i, param) in params.iter().enumerate() {
                            if i < arg_values.len() {
                                self.locals
                                    .last_mut()
                                    .unwrap()
                                    .insert(param.name.clone(), arg_values[i].clone());
                            }
                        }

                        // 执行函数体
                        let mut result = Value::null();
                        for stmt in body {
                            result = self.eval(stmt)?;
                            if self.return_value.is_some() {
                                result = self.return_value.take().unwrap();
                                break;
                            }
                        }

                        // 恢复局部变量
                        self.locals.pop();

                        return Ok(result);
                    }
                }

                // 如果上面的处理失败，尝试使用call_method
                let mut arg_values = Vec::new();
                for arg in args {
                    arg_values.push(self.eval(&arg)?);
                }

                match obj_val.call_method(method, &arg_values) {
                    Ok(result) => Ok(result),
                    Err(e) => {
                        let error = invalid_operation_error("方法调用", &e);
                        if let Some(loc) = location {
                            Err(error.with_location(".".to_string(), loc.line, loc.column))
                        } else {
                            Err(error)
                        }
                    }
                }
            }

            ASTNode::String(s, _) => Ok(Value::string(s.clone())),
            ASTNode::StringInterpolation { parts, .. } => {
                let mut result = String::new();

                for part in parts {
                    match part {
                        crate::ast::StringInterpolationPart::Text(text) => {
                            result.push_str(&text);
                        }
                        crate::ast::StringInterpolationPart::Expression(expr) => {
                            let value = self.eval(expr)?;
                            let string_value = match value.data {
                                ValueData::String(s) => s,
                                ValueData::Number(n) => n.to_string(),
                                ValueData::Boolean(b) => {
                                    if b {
                                        "真".to_string()
                                    } else {
                                        "伪".to_string()
                                    }
                                }
                                ValueData::Null => "无".to_string(),
                                ValueData::Set(items) => {
                                    let set = items.borrow();
                                    let mut elements = Vec::new();
                                    for item in set.iter() {
                                        let item_str = match &item.0.data {
                                            ValueData::String(s) => s.clone(),
                                            ValueData::Number(n) => {
                                                if *n == n.floor() {
                                                    format!("{}", *n as i64)
                                                } else {
                                                    format!("{}", n)
                                                }
                                            }
                                            ValueData::Boolean(b) => {
                                                if *b { "真" } else { "伪" }.to_string()
                                            }
                                            ValueData::Null => "无".to_string(),
                                            _ => item.0.to_string(),
                                        };
                                        elements.push(item_str);
                                    }
                                    elements.sort(); // 排序保证输出一致性
                                    format!("{{{}}}", elements.join("、"))
                                }
                                ValueData::Dict(items) => {
                                    let dict = items.borrow();
                                    let mut pairs = Vec::new();
                                    for (key, val) in dict.iter() {
                                        let val_str = match &val.data {
                                            ValueData::String(s) => format!("「{}」", s),
                                            ValueData::Number(n) => {
                                                if *n == n.floor() {
                                                    format!("{}", *n as i64)
                                                } else {
                                                    format!("{}", n)
                                                }
                                            }
                                            ValueData::Boolean(b) => {
                                                if *b { "真" } else { "伪" }.to_string()
                                            }
                                            ValueData::Null => "无".to_string(),
                                            _ => val.to_string(),
                                        };
                                        pairs.push(format!("「{}」： {}", key, val_str));
                                    }
                                    pairs.sort(); // 按键排序，保证输出一致性
                                    format!("《{}》", pairs.join("、 "))
                                }
                                ValueData::List(items) => {
                                    let list = items.borrow();
                                    let mut elements = Vec::new();
                                    for item in list.iter() {
                                        let item_str = match &item.data {
                                            //ValueData::String(s) => s.clone(),
                                            ValueData::String(s) => format!("「{}」", s.clone()),
                                            ValueData::Number(n) => {
                                                if *n == n.floor() {
                                                    format!("{}", *n as i64)
                                                } else {
                                                    format!("{}", n)
                                                }
                                            }
                                            ValueData::Boolean(b) => {
                                                if *b { "真" } else { "伪" }.to_string()
                                            }
                                            ValueData::Null => "无".to_string(),
                                            ValueData::List(_) => {
                                                // 对于嵌套列表，递归获取其字符串表示
                                                let nested_str = item.to_string();
                                                // 去掉外层的【】
                                                if nested_str.starts_with("【")
                                                    && nested_str.ends_with("】")
                                                {
                                                    let chars: Vec<char> =
                                                        nested_str.chars().collect();
                                                    let len = chars.len();
                                                    if len >= 2 {
                                                        chars[1..len - 1].iter().collect::<String>()
                                                    } else {
                                                        nested_str
                                                    }
                                                } else {
                                                    nested_str
                                                }
                                            }
                                            ValueData::Set(_) => {
                                                // 对于嵌套集合，获取其字符串表示
                                                item.to_string()
                                            }
                                            ValueData::Dict(_) => {
                                                // 对于嵌套字典，获取其字符串表示
                                                item.to_string()
                                            }
                                            _ => item.to_string(),
                                        };
                                        elements.push(item_str);
                                    }
                                    format!("【{}】", elements.join("、"))
                                }
                                ValueData::Tuple(_) => "[元组]".to_string(),
                                ValueData::Function { .. } => "[函数]".to_string(),
                                ValueData::Closure(_) => "[闭包]".to_string(),
                                ValueData::Object(_) => "[对象]".to_string(),
                            };
                            result.push_str(&string_value);
                        }
                    }
                }

                Ok(Value::string(result))
            }
            ASTNode::Number(n, _) => Ok(Value::number(*n)),
            ASTNode::Array(elements, _) => {
                let mut values = Vec::new();
                for elem in elements {
                    values.push(self.eval(elem)?);
                }
                Ok(Value::list(values))
            }
            ASTNode::ArrayAccess {
                array,
                index,
                location,
            } => {
                let arr = self.eval(array)?;
                let idx = self.eval(index)?;

                match (&arr.data, &idx.data) {
                    (ValueData::List(elements), ValueData::Number(n)) => {
                        let index = *n as usize;
                        let elements_ref = elements.borrow();
                        if index < elements_ref.len() {
                            Ok(elements_ref[index].clone())
                        } else {
                            let error = index_out_of_bounds_error(index, elements_ref.len());
                            if let Some(loc) = location {
                                Err(error.with_location(".".to_string(), loc.line, loc.column))
                            } else {
                                Err(error)
                            }
                        }
                    }
                    (ValueData::String(s), ValueData::Number(n)) => {
                        let index = *n as usize;
                        if index < s.len() {
                            Ok(Value::string(s.chars().nth(index).unwrap().to_string()))
                        } else {
                            let error = index_out_of_bounds_error(index, s.len());
                            if let Some(loc) = location {
                                Err(error.with_location(".".to_string(), loc.line, loc.column))
                            } else {
                                Err(error)
                            }
                        }
                    }
                    _ => Err(invalid_operation_error("索引访问", "非数组或字符串类型")),
                }
            }
            ASTNode::ArrayPush {
                array: _,
                value,
                location: _,
            } => {
                let _val = self.eval(value)?;
                Ok(Value::null())
            }

            // 处理Break节点
            ASTNode::Break(_) => {
                if self.in_loop {
                    self.should_break = true;
                    Ok(Value::null())
                } else {
                    Err(self.format_error("break语句只能在循环中使用", None))
                }
            }

            // 处理Continue节点
            ASTNode::Continue(_) => {
                if self.in_loop {
                    self.should_continue = true;
                    Ok(Value::null())
                } else {
                    Err(self.format_error("continue语句只能在循环中使用", None))
                }
            }

            // 处理Integer节点
            ASTNode::Integer(value, _) => Ok(Value::number(*value as f64)),

            // 处理Float节点
            ASTNode::Float(value, _) => Ok(Value::number(*value)),

            // 处理Boolean节点
            ASTNode::Boolean(value, _) => Ok(Value::boolean(*value)),

            // 处理List节点
            ASTNode::List(elements, _) => {
                let mut list = Vec::new();
                for element in elements {
                    let val = self.eval(element)?;
                    list.push(val);
                }
                Ok(Value::list(list))
            }

            // 处理Set节点
            ASTNode::Set(elements, _) => {
                let mut set = Vec::new();
                for element in elements {
                    let val = self.eval(element)?;
                    set.push(val);
                }
                Ok(crate::interpreter::collections::set::Set::create(set))
            }

            // 处理Dict节点
            ASTNode::Dict(pairs, _) => {
                let mut dict = std::collections::HashMap::new();
                for (key, value) in pairs {
                    let key_val = self.eval(key)?;
                    let val_val = self.eval(value)?;

                    // 将键转换为字符串
                    let key_str = match &key_val.data {
                        ValueData::Number(n) => {
                            if *n == n.floor() {
                                format!("{}", *n as i64)
                            } else {
                                format!("{}", n)
                            }
                        }
                        ValueData::String(s) => s.clone(),
                        ValueData::Boolean(b) => if *b { "真" } else { "伪" }.to_string(),
                        _ => {
                            return Err(type_mismatch_error(
                                "支持的字典键类型",
                                &key_val.get_type_name(),
                            )
                            .into());
                        }
                    };

                    dict.insert(key_str, val_val);
                }
                Ok(Value::dict(dict))
            }

            // 处理Null节点
            ASTNode::Null(_) => Ok(Value::null()),
        }
    }

    // 调用函数 - 支持位置参数和关键字参数，并实现尾递归优化
    pub fn call_function_with_args(
        &mut self,
        name: &str,
        args: &[Argument],
        location: &Option<SourceLocation>,
    ) -> Result<Value, RuntimeError> {
        // 增加递归深度并检查是否超过限制
        self.increment_recursion_depth()?;

        // 检查是否是内置函数
        let func = match self.functions.get(name) {
            Some(func) => func.clone(),
            None => {
                // 函数调用结束，减少递归深度
                self.decrement_recursion_depth();
                return Err(self.format_error(&format!("未定义的函数: {}", name), None));
            }
        };

        let result = self.execute_function_call(&func, name, args, location)?;

        // 函数调用结束，减少递归深度
        self.decrement_recursion_depth();
        Ok(result)
    }

    // 执行普通函数调用
    fn execute_function_call(
        &mut self,
        func: &Value,
        name: &str,
        args: &[Argument],
        location: &Option<SourceLocation>,
    ) -> Result<Value, RuntimeError> {
        let result = match &func.data {
            ValueData::Function {
                params,
                body,
                closure: _,
                return_type: _,
            } => {
                // 分析传入的参数 - 先评估所有参数值
                let mut positional_args = Vec::new();
                let mut keyword_args = HashMap::new();

                for arg in args {
                    match arg {
                        Argument::Positional(ast_node, _) => {
                            // 先评估参数值，避免借用冲突
                            let value = self.eval(ast_node)?;
                            positional_args.push(value);
                        }
                        Argument::Keyword(param_name, ast_node, _) => {
                            // 先评估参数值，避免借用冲突
                            let value = self.eval(ast_node)?;
                            keyword_args.insert(param_name.clone(), value);
                        }
                    }
                }

                // 保存当前局部变量并创建新的局部作用域
                self.locals.push(HashMap::new());

                // 处理参数绑定
                let mut bound_params = HashMap::new();
                let mut positional_param_index = 0;

                if self.config.execution_mode.is_debug() {
                    self.debug_println(format_args!("=== 参数绑定调试 ==="));
                    self.debug_println(format_args!("函数参数: {:?}", params));
                    self.debug_println(format_args!(
                        "位置参数数量: {}, 内容: {:?}",
                        positional_args.len(),
                        positional_args
                    ));
                    self.debug_println(format_args!("关键字参数: {:?}", keyword_args));
                }

                for param in params.iter() {
                    let param_name: &String = &param.name;
                    if self.config.execution_mode.is_debug() {
                        self.debug_println(format_args!(
                            "正在绑定参数: {}, 位置参数索引: {}",
                            param_name, positional_param_index
                        ));
                    }

                    if let Some(value) = keyword_args.get(param_name) {
                        // 关键字参数
                        if self.config.execution_mode.is_debug() {
                            self.debug_println(format_args!("  使用关键字参数: {:?}", value));
                        }
                        // 类型检查
                        if let Some(ref type_name) = param.type_name {
                            self.validate_parameter_type(value, type_name.as_str(), param_name)?;
                        }
                        bound_params.insert(param_name.clone(), value.clone());
                    } else if positional_param_index < positional_args.len() {
                        // 位置参数
                        let value = &positional_args[positional_param_index];
                        if self.config.execution_mode.is_debug() {
                            self.debug_println(format_args!(
                                "  使用位置参数[{}]: {:?}",
                                positional_param_index, value
                            ));
                        }
                        // 类型检查
                        if let Some(ref type_name) = param.type_name {
                            self.validate_parameter_type(value, type_name.as_str(), param_name)?;
                        }
                        bound_params.insert(param_name.clone(), value.clone());
                        positional_param_index += 1;
                    } else if param.default_value.is_some() {
                        // 使用默认值
                        let default_value = self.eval(&param.default_value.as_ref().unwrap())?;
                        if self.config.execution_mode.is_debug() {
                            self.debug_println(format_args!("  使用默认值: {:?}", default_value));
                        }
                        // 类型检查
                        if let Some(ref type_name) = param.type_name {
                            self.validate_parameter_type(
                                &default_value,
                                type_name.as_str(),
                                param_name,
                            )?;
                        }
                        bound_params.insert(param_name.clone(), default_value);
                    } else {
                        // 缺少必需参数且没有默认值
                        if self.config.execution_mode.is_debug() {
                            self.debug_println(format_args!("  缺少参数: {}", param_name));
                        }
                        let error = crate::errors::argument_mismatch_error(
                            params.len(),
                            positional_args.len(),
                        );
                        if let Some(loc) = location {
                            return Err(error.with_location(
                                name.to_string(),
                                loc.line,
                                loc.column,
                            ));
                        } else {
                            return Err(error);
                        }
                    }
                }
                if self.config.execution_mode.is_debug() {
                    self.debug_println(format_args!("绑定结果: {:?}", bound_params));
                    self.debug_println(format_args!("=== 绑定调试结束 ===\n"));
                }

                // 检查是否有多余的位置参数
                if positional_param_index < positional_args.len() {
                    let error =
                        crate::errors::argument_mismatch_error(params.len(), positional_args.len());
                    self.decrement_recursion_depth();
                    if let Some(loc) = location {
                        return Err(error.with_location(name.to_string(), loc.line, loc.column));
                    } else {
                        return Err(error);
                    }
                }

                // 将绑定好的参数添加到作用域
                {
                    let current_scope = self.locals.last_mut().unwrap();
                    for (param_name, value) in bound_params {
                        current_scope.insert(param_name, value);
                    }
                }

                // 执行函数体
                let mut result = Value::null();
                for stmt in body {
                    result = self.eval(stmt)?;
                    if self.return_value.is_some() {
                        result = self.return_value.take().unwrap();
                        break;
                    }
                }

                // 检查返回值类型
                if let ValueData::Function { return_type, .. } = &func.data {
                    if let Some(expected_return_type) = return_type {
                        // 检查返回值类型是否匹配
                        let actual_type = &result.type_name;
                        if actual_type != expected_return_type {
                            self.decrement_recursion_depth();
                            return Err(self.format_error(
                                &format!(
                                    "函数 '{}' 返回值类型错误：期望 '{}'，但实际返回了 '{}'",
                                    name, expected_return_type, actual_type
                                ),
                                None,
                            ));
                        }
                    }
                }

                // 恢复之前的局部变量
                self.locals.pop();
                result
            }
            _ => {
                self.decrement_recursion_depth();
                return Err(self.format_error(&format!("{} 不是函数", name), None));
            }
        };

        // 函数调用结束，减少递归深度
        self.decrement_recursion_depth();
        Ok(result)
    }

    // 原来的call_function方法保持不变，以兼容现有代码
    pub fn call_function(
        &mut self,
        name: &str,
        args: &[Value],
        location: &Option<SourceLocation>,
    ) -> Result<Value, RuntimeError> {
        // 将简单值数组转换为Argument向量
        let args_as_arguments: Vec<Argument> = args
            .iter()
            .enumerate()
            .map(|(_index, val)| {
                // 创建临时的ASTNode来表示值
                let ast_node = match val {
                    Value {
                        data: ValueData::Number(n),
                        ..
                    } => ASTNode::Number(*n, None),
                    Value {
                        data: ValueData::String(s),
                        ..
                    } => ASTNode::String(s.clone(), None),
                    Value {
                        data: ValueData::Boolean(b),
                        ..
                    } => ASTNode::Boolean(*b, None),
                    Value {
                        data: ValueData::Null,
                        ..
                    } => ASTNode::Null(None),
                    _ => ASTNode::Null(None), // 其他类型暂时用Null表示
                };
                Argument::Positional(ast_node, None)
            })
            .collect();

        // 使用call_function_with_args来处理参数
        self.call_function_with_args(name, &args_as_arguments, location)
    }

    // 计算二元操作
    pub fn eval_binary_op(
        &self,
        left: &Value,
        op: &BinOp,
        right: &Value,
    ) -> Result<Value, RuntimeError> {
        match (left, op, right) {
            // 数字操作
            (
                Value {
                    data: ValueData::Number(l),
                    ..
                },
                BinOp::Add,
                Value {
                    data: ValueData::Number(r),
                    ..
                },
            ) => Ok(Value::number(l + r)),
            (
                Value {
                    data: ValueData::Number(l),
                    ..
                },
                BinOp::Sub,
                Value {
                    data: ValueData::Number(r),
                    ..
                },
            ) => Ok(Value::number(l - r)),
            (
                Value {
                    data: ValueData::Number(l),
                    ..
                },
                BinOp::Mul,
                Value {
                    data: ValueData::Number(r),
                    ..
                },
            ) => Ok(Value::number(l * r)),
            (
                Value {
                    data: ValueData::Number(l),
                    ..
                },
                BinOp::Div,
                Value {
                    data: ValueData::Number(r),
                    ..
                },
            ) => {
                if *r == 0.0 {
                    Err(invalid_operation_error("除法运算", "除数不能为零"))
                } else {
                    Ok(Value::number(l / r))
                }
            }
            (
                Value {
                    data: ValueData::Number(l),
                    ..
                },
                BinOp::Mod,
                Value {
                    data: ValueData::Number(r),
                    ..
                },
            ) => Ok(Value::number(l % r)),
            (
                Value {
                    data: ValueData::Number(l),
                    ..
                },
                BinOp::FloorDiv,
                Value {
                    data: ValueData::Number(r),
                    ..
                },
            ) => {
                if *r == 0.0 {
                    Err(invalid_operation_error("整除运算", "除数不能为零"))
                } else {
                    Ok(Value::number((l / r).floor()))
                }
            }
            (
                Value {
                    data: ValueData::Number(l),
                    ..
                },
                BinOp::Lt,
                Value {
                    data: ValueData::Number(r),
                    ..
                },
            ) => Ok(Value::boolean(l < r)),
            (
                Value {
                    data: ValueData::Number(l),
                    ..
                },
                BinOp::Le,
                Value {
                    data: ValueData::Number(r),
                    ..
                },
            ) => Ok(Value::boolean(l <= r)),
            (
                Value {
                    data: ValueData::Number(l),
                    ..
                },
                BinOp::Gt,
                Value {
                    data: ValueData::Number(r),
                    ..
                },
            ) => Ok(Value::boolean(l > r)),
            (
                Value {
                    data: ValueData::Number(l),
                    ..
                },
                BinOp::Ge,
                Value {
                    data: ValueData::Number(r),
                    ..
                },
            ) => Ok(Value::boolean(l >= r)),
            (
                Value {
                    data: ValueData::Number(l),
                    ..
                },
                BinOp::Eq,
                Value {
                    data: ValueData::Number(r),
                    ..
                },
            ) => Ok(Value::boolean(l == r)),
            (
                Value {
                    data: ValueData::Number(l),
                    ..
                },
                BinOp::Ne,
                Value {
                    data: ValueData::Number(r),
                    ..
                },
            ) => Ok(Value::boolean(l != r)),

            // 字符串操作
            (
                Value {
                    data: ValueData::String(l),
                    ..
                },
                BinOp::Add,
                Value {
                    data: ValueData::String(r),
                    ..
                },
            ) => Ok(Value::string(format!("{}{}", l, r))),
            (
                Value {
                    data: ValueData::String(l),
                    ..
                },
                BinOp::Mul,
                Value {
                    data: ValueData::Number(r),
                    ..
                },
            ) => {
                // 字符串重复操作
                if *r < 0.0 {
                    return Err(invalid_operation_error("字符串乘法", "重复次数不能为负数"));
                }
                let count = *r as usize;
                Ok(Value::string(l.repeat(count)))
            }
            (
                Value {
                    data: ValueData::Number(l),
                    ..
                },
                BinOp::Mul,
                Value {
                    data: ValueData::String(r),
                    ..
                },
            ) => {
                // 数字乘字符串操作（支持 40 乘 "*" 语法）
                if *l < 0.0 {
                    return Err(invalid_operation_error("字符串乘法", "重复次数不能为负数"));
                }
                let count = *l as usize;
                Ok(Value::string(r.repeat(count)))
            }
            (
                Value {
                    data: ValueData::String(l),
                    ..
                },
                BinOp::Add,
                right_val,
            ) => {
                // 字符串拼接：其他类型自动转为字符串
                Ok(Value::string(format!("{}{}", l, right_val.to_string())))
            }
            (
                left_val,
                BinOp::Add,
                Value {
                    data: ValueData::String(r),
                    ..
                },
            ) => {
                // 字符串拼接：其他类型自动转为字符串
                Ok(Value::string(format!("{}{}", left_val.to_string(), r)))
            }
            (
                Value {
                    data: ValueData::String(l),
                    ..
                },
                BinOp::Eq,
                Value {
                    data: ValueData::String(r),
                    ..
                },
            ) => Ok(Value::boolean(l == r)),
            (
                Value {
                    data: ValueData::String(l),
                    ..
                },
                BinOp::Ne,
                Value {
                    data: ValueData::String(r),
                    ..
                },
            ) => Ok(Value::boolean(l != r)),

            // 布尔操作
            (
                Value {
                    data: ValueData::Boolean(l),
                    ..
                },
                BinOp::And,
                Value {
                    data: ValueData::Boolean(r),
                    ..
                },
            ) => Ok(Value::boolean(*l && *r)),
            (
                Value {
                    data: ValueData::Boolean(l),
                    ..
                },
                BinOp::Or,
                Value {
                    data: ValueData::Boolean(r),
                    ..
                },
            ) => Ok(Value::boolean(*l || *r)),
            (
                Value {
                    data: ValueData::Boolean(l),
                    ..
                },
                BinOp::Eq,
                Value {
                    data: ValueData::Boolean(r),
                    ..
                },
            ) => Ok(Value::boolean(*l == *r)),
            (
                Value {
                    data: ValueData::Boolean(l),
                    ..
                },
                BinOp::Ne,
                Value {
                    data: ValueData::Boolean(r),
                    ..
                },
            ) => Ok(Value::boolean(*l != *r)),

            // 空值比较
            (
                Value {
                    data: ValueData::Null,
                    ..
                },
                BinOp::Eq,
                Value {
                    data: ValueData::Null,
                    ..
                },
            ) => Ok(Value::boolean(true)),
            (
                Value {
                    data: ValueData::Null,
                    ..
                },
                BinOp::Ne,
                Value {
                    data: ValueData::Null,
                    ..
                },
            ) => Ok(Value::boolean(false)),
            (
                Value {
                    data: ValueData::Null,
                    ..
                },
                BinOp::Eq,
                _,
            ) => Ok(Value::boolean(false)),
            (
                Value {
                    data: ValueData::Null,
                    ..
                },
                BinOp::Ne,
                _,
            ) => Ok(Value::boolean(true)),
            (
                _,
                BinOp::Eq,
                Value {
                    data: ValueData::Null,
                    ..
                },
            ) => Ok(Value::boolean(false)),
            (
                _,
                BinOp::Ne,
                Value {
                    data: ValueData::Null,
                    ..
                },
            ) => Ok(Value::boolean(true)),

            // 相等比较
            (l, BinOp::Eq, r) => Ok(Value::boolean(l == r)),
            (l, BinOp::Ne, r) => Ok(Value::boolean(l != r)),

            _ => Err(invalid_operation_error(
                "二元操作",
                &format!(
                    "不支持的操作数类型组合: {} 和 {}",
                    left.get_type_name(),
                    right.get_type_name()
                ),
            )),
        }
    }

    // 计算一元操作
    pub fn eval_unary_op(&self, op: &String, operand: &Value) -> Result<Value, RuntimeError> {
        match (op.as_str(), &operand.data) {
            ("-", ValueData::Number(n)) => Ok(Value::number(-n)),
            ("!", ValueData::Boolean(b)) => Ok(Value::boolean(!b)),
            ("!", ValueData::Null) => Ok(Value::boolean(true)),
            ("!", ValueData::Number(n)) => Ok(Value::boolean(*n == 0.0)),
            ("!", ValueData::String(s)) => Ok(Value::boolean(s.is_empty())),
            ("!", ValueData::List(elements)) => Ok(Value::boolean(elements.borrow().is_empty())),
            ("!", ValueData::Dict(items)) => Ok(Value::boolean(items.borrow().is_empty())),
            ("!", ValueData::Set(items)) => Ok(Value::boolean(items.borrow().is_empty())),
            _ => Err(invalid_operation_error(
                "一元操作",
                &format!("不支持的操作数类型: {}", operand.type_name),
            )),
        }
    }

    // 加载模块
    pub fn load_module(
        &mut self,
        path: &str,
        symbols: Option<&[String]>,
    ) -> Result<(), RuntimeError> {
        self.load_module_from_path(&PathBuf::from(path), symbols)
    }

    // 从文件路径加载模块
    pub fn load_module_from_path(
        &mut self,
        path: &PathBuf,
        symbols: Option<&[String]>,
    ) -> Result<(), RuntimeError> {
        // 解析路径，如果是相对路径，则基于当前文件的目录来解析
        let resolved_path = if path.is_relative() {
            if let Some(current_file) = &self.current_file_path {
                if let Some(parent_dir) = current_file.parent() {
                    parent_dir.join(path)
                } else {
                    path.clone()
                }
            } else {
                path.clone()
            }
        } else {
            path.clone()
        };

        // 检查是否已经加载过该模块
        let module_name = resolved_path.file_stem().unwrap().to_str().unwrap();
        if self.constants.contains_key(module_name) {
            return Ok(());
        }

        // 从文件加载代码
        let code = std::fs::read_to_string(&resolved_path)
            .map_err(|e| invalid_operation_error("模块加载", &format!("无法读取文件: {}", e)))?;

        // 解析代码
        let mut lexer = crate::lexer::lexer::Lexer::new_with_config(&code, self.config.clone());
        let tokens = match lexer.tokenize() {
            Ok(tokens) => tokens,
            Err(err) => {
                return Err(invalid_operation_error(
                    "模块加载",
                    &format!("词法分析失败: {}", err),
                ));
            }
        };
        let mut parser = crate::parser::parser::Parser::new(
            tokens,
            resolved_path.to_str().unwrap().to_string(),
            code.clone(),
        );
        let ast = match parser.parse() {
            Ok(ast) => ast,
            Err(err) => {
                return Err(invalid_operation_error(
                    "模块加载",
                    &format!("语法分析失败: {}", err),
                ));
            }
        };

        // 执行模块
        self.eval(&ast)?;

        // 如果指定了符号，则只导出这些符号
        if let Some(export_symbols) = symbols {
            self.exports.clear();
            for symbol in export_symbols {
                self.exports.insert(symbol.clone());
            }
        }

        Ok(())
    }

    // 获取变量值
    pub fn get_variable(&self, name: &str) -> Result<Value, RuntimeError> {
        // 检查当前局部作用域
        for scope in self.locals.iter().rev() {
            if let Some(val) = scope.get(name) {
                return Ok(val.clone());
            }
        }

        // 检查全局变量
        if let Some(val) = self.globals.get(name) {
            return Ok(val.clone());
        }

        Err(crate::errors::undefined_identifier_error(name))
    }

    // 设置变量值
    pub fn set_variable(&mut self, name: String, value: Value) {
        // 检查当前局部作用域
        for scope in self.locals.iter_mut().rev() {
            if scope.contains_key(&name) {
                scope.insert(name, value);
                return;
            }
        }

        // 否则设置为全局变量
        self.globals.insert(name, value);
    }

    // 检查值是否为真
    pub fn is_truthy(&self, value: &Value) -> bool {
        match &value.data {
            ValueData::Boolean(b) => *b,
            ValueData::Number(n) => *n != 0.0,
            ValueData::String(s) => !s.is_empty(),
            ValueData::Null => false,
            ValueData::List(elements) => !elements.borrow().is_empty(),
            ValueData::Dict(items) => !items.borrow().is_empty(),
            ValueData::Set(items) => !items.borrow().is_empty(),
            ValueData::Tuple(items) => !items.is_empty(),
            ValueData::Closure(_) => true,
            ValueData::Function { .. } => true,
            ValueData::Object { .. } => true,
        }
    }

    pub fn set_current_file_path(&mut self, path: PathBuf) {
        self.current_file_path = Some(path);
    }

    /// 验证参数类型是否匹配
    pub fn validate_parameter_type(
        &self,
        value: &Value,
        type_name: &str,
        param_name: &str,
    ) -> Result<(), RuntimeError> {
        let actual_type = match &value.data {
            ValueData::Number(_) => "数",
            ValueData::String(_) => "文",
            ValueData::Boolean(_) => "真伪",
            ValueData::Null => "无",
            ValueData::List(_) => "集", // 修改：列表类型应为"集"而不是"表"
            ValueData::Dict(_) => "辞", // 修改：字典类型应为"辞"而不是"典"
            ValueData::Set(_) => "汇",  // 修改：集合类型应为"汇"而不是"集"
            ValueData::Tuple(_) => "组", // 修改：元组类型应为"组"而不是"元组"
            ValueData::Closure(_) => "闭", // 闭包类型
            ValueData::Function { .. } => "函",
            ValueData::Object { .. } => "物",
        };

        // 支持类型别名和简写
        let normalized_type = match type_name {
            "整数" | "数" | "Number" => "数",
            "文" | "字符串" | "String" => "文",
            "真伪" | "布尔" | "Boolean" => "真伪",
            "无" | "空" | "Null" => "无",
            "集" | "列表" | "List" => "集",  // 修改：列表类型为"集"
            "辞" | "字典" | "Dict" => "辞",  // 修改：字典类型为"辞"
            "汇" | "集合" | "Set" => "汇",   // 修改：集合类型为"汇"
            "组" | "元组" | "Tuple" => "组", // 修改：元组类型为"组"
            "函" | "函数" | "Function" => "函",
            "物" | "对象" | "Object" => "物",
            other => other, // 保持原样，允许自定义类型
        };

        if actual_type == normalized_type {
            Ok(())
        } else {
            Err(self.format_error(
                &format!(
                    "参数类型错误：参数 '{}' 期望类型 '{}'，但得到 '{}'",
                    param_name, normalized_type, actual_type
                ),
                None,
            ))
        }
    }

    // 格式化错误信息
    pub fn format_error(&self, message: &str, node: Option<&ASTNode>) -> RuntimeError {
        let error = invalid_operation_error("运行时错误", message);
        if let Some(n) = node {
            // 尝试获取位置信息
            match n {
                ASTNode::FunctionCall { location, .. }
                | ASTNode::MemberAccess { location, .. }
                | ASTNode::MemberAssign { location, .. }
                | ASTNode::MethodCall { location, .. }
                | ASTNode::ArrayAccess { location, .. } => {
                    if let Some(loc) = location {
                        return error.with_location("unknown".to_string(), loc.line, loc.column);
                    }
                }
                _ => {}
            }
        }
        error
    }

    /// 直接执行函数值
    pub fn execute_function_value(
        &mut self,
        func_value: &Value,
        args: &[Value],
    ) -> Result<Value, RuntimeError> {
        match &func_value.data {
            ValueData::Function {
                params,
                body,
                closure,
                return_type: _,
            } => {
                // 保存当前全局变量状态，以便在函数执行后恢复
                let mut saved_globals = HashMap::new();

                // 设置闭包变量，同时保存原始值以便恢复
                for (name, val) in closure.borrow().iter() {
                    if let Some(original_value) = self.globals.get(name) {
                        saved_globals.insert(name.clone(), original_value.clone());
                    }
                    self.globals.insert(name.clone(), val.clone());
                }

                // 保存当前局部变量并创建新的局部作用域
                self.locals.push(HashMap::new());

                // 绑定参数到局部变量
                for (i, param) in params.iter().enumerate() {
                    if i < args.len() {
                        self.locals
                            .last_mut()
                            .unwrap()
                            .insert(param.name.clone(), args[i].clone());
                    }
                }

                // 执行函数体
                let mut result = Value::null();
                for stmt in body {
                    result = self.eval(stmt)?;
                    // 检查是否有返回语句
                    if self.return_value.is_some() {
                        result = self.return_value.take().unwrap();
                        break;
                    }
                }

                // 清理局部变量
                self.locals.pop();

                // 恢复全局变量到原始状态
                for (name, _) in closure.borrow().iter() {
                    if let Some(original_value) = saved_globals.get(name) {
                        self.globals.insert(name.clone(), original_value.clone());
                    } else {
                        // 如果原来没有这个变量，则删除它
                        self.globals.remove(name);
                    }
                }

                Ok(result)
            }
            _ => Err(self.format_error("不是一个函数", None)),
        }
    }
}
